home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1999 March / EnigmA AMIGA RUN 35 (1999)(G.R. Edizioni)(IT)[!][issue 1999-03].iso / earcd / devel / flash-0.4.3 / plugin / jri_md.h next >
C/C++ Source or Header  |  1999-01-01  |  22KB  |  501 lines
  1. /* -*- Mode: C; tab-width: 4; -*- */
  2. /*******************************************************************************
  3.  * Java Runtime Interface - Machine Dependent Types
  4.  * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
  5.  ******************************************************************************/
  6.  
  7. #ifndef JRI_MD_H
  8. #define JRI_MD_H
  9.  
  10. #include <assert.h>
  11.  
  12. #ifdef __cplusplus
  13. extern "C" {
  14. #endif
  15.  
  16. /*******************************************************************************
  17.  * WHAT'S UP WITH THIS FILE?
  18.  * 
  19.  * This is where we define the mystical JRI_PUBLIC_API macro that works on all
  20.  * platforms. If you're running with Visual C++, Symantec C, or Borland's 
  21.  * development environment on the PC, you're all set. Or if you're on the Mac
  22.  * with Metrowerks, Symantec or MPW with SC you're ok too. For UNIX it shouldn't
  23.  * matter.
  24.  *
  25.  * On UNIX though you probably care about a couple of other symbols though:
  26.  *    IS_LITTLE_ENDIAN must be defined for little-endian systems
  27.  *    HAVE_LONG_LONG must be defined on systems that have 'long long' integers
  28.  *    HAVE_ALIGNED_LONGLONGS must be defined if long-longs must be 8 byte aligned
  29.  *    HAVE_ALIGNED_DOUBLES must be defined if doubles must be 8 byte aligned
  30.  *    IS_64 must be defined on 64-bit machines (like Dec Alpha)
  31.  ******************************************************************************/
  32.  
  33. /* DLL Entry modifiers... */
  34.  
  35. /* PC */
  36. #if defined(XP_PC) || defined(_WINDOWS) || defined(WIN32) || defined(_WIN32)
  37. #    include <windows.h>
  38. #    if defined(_MSC_VER)
  39. #        if defined(WIN32) || defined(_WIN32)
  40. #            define JRI_PUBLIC_API(ResultType)    _declspec(dllexport) ResultType
  41. #            define JRI_CALLBACK
  42. #        else /* !_WIN32 */
  43. #            if defined(_WINDLL)
  44. #            define JRI_PUBLIC_API(ResultType)    ResultType __cdecl __export __loadds 
  45. #            define JRI_CALLBACK            __loadds
  46. #            else /* !WINDLL */
  47. #            define JRI_PUBLIC_API(ResultType)    ResultType __cdecl __export
  48. #            define JRI_CALLBACK            __export
  49. #                   endif /* !WINDLL */
  50. #        endif /* !_WIN32 */
  51. #    elif defined(__BORLANDC__)
  52. #        if defined(WIN32) || defined(_WIN32)
  53. #            define JRI_PUBLIC_API(ResultType)    __export ResultType
  54. #            define JRI_CALLBACK
  55. #        else /* !_WIN32 */
  56. #            define JRI_PUBLIC_API(ResultType)    ResultType _cdecl _export _loadds 
  57. #            define JRI_CALLBACK                    _loadds
  58. #        endif
  59. #    else
  60. #        error Unsupported PC development environment.    
  61. #    endif
  62. #    ifndef IS_LITTLE_ENDIAN
  63. #        define IS_LITTLE_ENDIAN
  64. #    endif
  65.  
  66. /* Mac */
  67. #elif macintosh || Macintosh || THINK_C
  68. #    if defined(__MWERKS__)                /* Metrowerks */
  69. #        if !__option(enumsalwaysint)
  70. #            error You need to define 'Enums Always Int' for your project.
  71. #        endif
  72. #        if defined(GENERATING68K) && !GENERATINGCFM 
  73. #            if !__option(fourbyteints) 
  74. #                error You need to define 'Struct Alignment: 68k' for your project.
  75. #            endif
  76. #        endif /* !GENERATINGCFM */
  77. #    elif defined(__SC__)                /* Symantec */
  78. #        error What are the Symantec defines? (warren@netscape.com)
  79. #    elif macintosh && applec            /* MPW */
  80. #        error Please upgrade to the latest MPW compiler (SC).
  81. #    else
  82. #        error Unsupported Mac development environment.
  83. #    endif
  84. #    define JRI_PUBLIC_API(ResultType)        ResultType
  85. #    define JRI_CALLBACK
  86.  
  87. /* Unix or else */
  88. #else
  89. #    define JRI_PUBLIC_API(ResultType)        ResultType
  90. #    define JRI_CALLBACK
  91. #endif
  92.  
  93. #ifndef FAR        /* for non-Win16 */
  94. #define FAR
  95. #endif
  96.  
  97. /******************************************************************************/
  98.  
  99. /* Java Scalar Types */
  100.  
  101. typedef unsigned char    jbool;
  102. typedef char            jbyte;
  103. typedef short            jchar;
  104. typedef short            jshort;
  105. #ifdef IS_64 /* XXX ok for alpha, but not right on all 64-bit architectures */
  106. typedef unsigned int    juint;
  107. typedef int                jint;
  108. #else
  109. typedef unsigned long    juint;
  110. typedef long            jint;
  111. #endif
  112. typedef float            jfloat;
  113. typedef double            jdouble;
  114.  
  115. typedef juint            jsize;
  116.  
  117. /*******************************************************************************
  118.  * jlong : long long (64-bit signed integer type) support.
  119.  ******************************************************************************/
  120.  
  121. /*
  122. ** Bit masking macros.  (n must be <= 31 to be portable)
  123. */
  124. #define JRI_BIT(n)            ((juint)1 << (n))
  125. #define JRI_BITMASK(n)        (JRI_BIT(n) - 1)
  126.  
  127. #ifdef HAVE_LONG_LONG
  128.  
  129. #if !(defined(WIN32) || defined(_WIN32))
  130. typedef long long            jlong;
  131. typedef unsigned long long    julong;
  132.  
  133. #define jlong_MAXINT        0x7fffffffffffffffLL
  134. #define jlong_MININT        0x8000000000000000LL
  135. #define jlong_ZERO            0x0LL
  136.  
  137. #else
  138. typedef LONGLONG            jlong;
  139. typedef DWORDLONG            julong;
  140.  
  141. #define jlong_MAXINT        0x7fffffffffffffffi64
  142. #define jlong_MININT        0x8000000000000000i64
  143. #define jlong_ZERO            0x0i64
  144.  
  145. #endif
  146.  
  147. #define jlong_IS_ZERO(a)    ((a) == 0)
  148. #define jlong_EQ(a, b)        ((a) == (b))
  149. #define jlong_NE(a, b)        ((a) != (b))
  150. #define jlong_GE_ZERO(a)    ((a) >= 0)
  151. #define jlong_CMP(a, op, b)    ((a) op (b))
  152.  
  153. #define jlong_AND(r, a, b)    ((r) = (a) & (b))
  154. #define jlong_OR(r, a, b)    ((r) = (a) | (b))
  155. #define jlong_XOR(r, a, b)    ((r) = (a) ^ (b))
  156. #define jlong_OR2(r, a)        ((r) = (r) | (a))
  157. #define jlong_NOT(r, a)        ((r) = ~(a))
  158.  
  159. #define jlong_NEG(r, a)        ((r) = -(a))
  160. #define jlong_ADD(r, a, b)    ((r) = (a) + (b))
  161. #define jlong_SUB(r, a, b)    ((r) = (a) - (b))
  162.  
  163. #define jlong_MUL(r, a, b)    ((r) = (a) * (b))
  164. #define jlong_DIV(r, a, b)    ((r) = (a) / (b))
  165. #define jlong_MOD(r, a, b)    ((r) = (a) % (b))
  166.  
  167. #define jlong_SHL(r, a, b)    ((r) = (a) << (b))
  168. #define jlong_SHR(r, a, b)    ((r) = (a) >> (b))
  169. #define jlong_USHR(r, a, b)    ((r) = (julong)(a) >> (b))
  170. #define jlong_ISHL(r, a, b)    ((r) = ((jlong)(a)) << (b))
  171.  
  172. #define jlong_L2I(i, l)        ((i) = (int)(l))
  173. #define jlong_L2UI(ui, l)    ((ui) =(unsigned int)(l))
  174. #define jlong_L2F(f, l)        ((f) = (l))
  175. #define jlong_L2D(d, l)        ((d) = (l))
  176.  
  177. #define jlong_I2L(l, i)        ((l) = (i))
  178. #define jlong_UI2L(l, ui)    ((l) = (ui))
  179. #define jlong_F2L(l, f)        ((l) = (f))
  180. #define jlong_D2L(l, d)        ((l) = (d))
  181.  
  182. #define jlong_UDIVMOD(qp, rp, a, b)  \
  183.     (*(qp) = ((julong)(a) / (b)), \
  184.      *(rp) = ((julong)(a) % (b)))
  185.  
  186. #else  /* !HAVE_LONG_LONG */
  187.  
  188. typedef struct {
  189. #ifdef IS_LITTLE_ENDIAN
  190.     juint lo, hi;
  191. #else
  192.     juint hi, lo;
  193. #endif
  194. } jlong;
  195. typedef jlong                julong;
  196.  
  197. extern jlong jlong_MAXINT, jlong_MININT, jlong_ZERO;
  198.  
  199. #define jlong_IS_ZERO(a)    (((a).hi == 0) && ((a).lo == 0))
  200. #define jlong_EQ(a, b)        (((a).hi == (b).hi) && ((a).lo == (b).lo))
  201. #define jlong_NE(a, b)        (((a).hi != (b).hi) || ((a).lo != (b).lo))
  202. #define jlong_GE_ZERO(a)    (((a).hi >> 31) == 0)
  203.  
  204. /*
  205.  * NB: jlong_CMP and jlong_UCMP work only for strict relationals (<, >).
  206.  */
  207. #define jlong_CMP(a, op, b)    (((int32)(a).hi op (int32)(b).hi) ||          \
  208.                  (((a).hi == (b).hi) && ((a).lo op (b).lo)))
  209. #define jlong_UCMP(a, op, b)    (((a).hi op (b).hi) ||                    \
  210.                  (((a).hi == (b).hi) && ((a).lo op (b).lo)))
  211.  
  212. #define jlong_AND(r, a, b)    ((r).lo = (a).lo & (b).lo,                    \
  213.                  (r).hi = (a).hi & (b).hi)
  214. #define jlong_OR(r, a, b)    ((r).lo = (a).lo | (b).lo,                    \
  215.                  (r).hi = (a).hi | (b).hi)
  216. #define jlong_XOR(r, a, b)    ((r).lo = (a).lo ^ (b).lo,                    \
  217.                  (r).hi = (a).hi ^ (b).hi)
  218. #define jlong_OR2(r, a)        ((r).lo = (r).lo | (a).lo,                    \
  219.                  (r).hi = (r).hi | (a).hi)
  220. #define jlong_NOT(r, a)        ((r).lo = ~(a).lo,                              \
  221.                  (r).hi = ~(a).hi)
  222.  
  223. #define jlong_NEG(r, a)        ((r).lo = -(int32)(a).lo,                     \
  224.                  (r).hi = -(int32)(a).hi - ((r).lo != 0))
  225. #define jlong_ADD(r, a, b) {                                              \
  226.     jlong _a, _b;                                                         \
  227.     _a = a; _b = b;                                                       \
  228.     (r).lo = _a.lo + _b.lo;                                               \
  229.     (r).hi = _a.hi + _b.hi + ((r).lo < _b.lo);                            \
  230. }
  231.  
  232. #define jlong_SUB(r, a, b) {                                              \
  233.     jlong _a, _b;                                                         \
  234.     _a = a; _b = b;                                                       \
  235.     (r).lo = _a.lo - _b.lo;                                               \
  236.     (r).hi = _a.hi - _b.hi - (_a.lo < _b.lo);                             \
  237. }                                                                         \
  238.  
  239. /*
  240.  * Multiply 64-bit operands a and b to get 64-bit result r.
  241.  * First multiply the low 32 bits of a and b to get a 64-bit result in r.
  242.  * Then add the outer and inner products to r.hi.
  243.  */
  244. #define jlong_MUL(r, a, b) {                                              \
  245.     jlong _a, _b;                                                         \
  246.     _a = a; _b = b;                                                       \
  247.     jlong_MUL32(r, _a.lo, _b.lo);                                         \
  248.     (r).hi += _a.hi * _b.lo + _a.lo * _b.hi;                              \
  249. }
  250.  
  251. /* XXX _jlong_lo16(a) = ((a) << 16 >> 16) is better on some archs (not on mips) */
  252. #define _jlong_lo16(a)        ((a) & JRI_BITMASK(16))
  253. #define _jlong_hi16(a)        ((a) >> 16)
  254.  
  255. /*
  256.  * Multiply 32-bit operands a and b to get 64-bit result r.
  257.  * Use polynomial expansion based on primitive field element (1 << 16).
  258.  */
  259. #define jlong_MUL32(r, a, b) {                                            \
  260.      juint _a1, _a0, _b1, _b0, _y0, _y1, _y2, _y3;                        \
  261.      _a1 = _jlong_hi16(a), _a0 = _jlong_lo16(a);                          \
  262.      _b1 = _jlong_hi16(b), _b0 = _jlong_lo16(b);                          \
  263.      _y0 = _a0 * _b0;                                                     \
  264.      _y1 = _a0 * _b1;                                                     \
  265.      _y2 = _a1 * _b0;                                                     \
  266.      _y3 = _a1 * _b1;                                                     \
  267.      _y1 += _jlong_hi16(_y0);                   /* can't carry */         \
  268.      _y1 += _y2;                                /* might carry */         \
  269.      if (_y1 < _y2) _y3 += 1 << 16;             /* propagate */           \
  270.      (r).lo = (_jlong_lo16(_y1) << 16) + _jlong_lo16(_y0);                \
  271.      (r).hi = _y3 + _jlong_hi16(_y1);                                     \
  272. }
  273.  
  274. /*
  275.  * Divide 64-bit unsigned operand a by 64-bit unsigned operand b, setting *qp
  276.  * to the 64-bit unsigned quotient, and *rp to the 64-bit unsigned remainder.
  277.  * Minimize effort if one of qp and rp is null.
  278.  */
  279. #define jlong_UDIVMOD(qp, rp, a, b)    jlong_udivmod(qp, rp, a, b)
  280.  
  281. extern JRI_PUBLIC_API(void)
  282. jlong_udivmod(julong *qp, julong *rp, julong a, julong b);
  283.  
  284. #define jlong_DIV(r, a, b) {                                              \
  285.     jlong _a, _b;                                                         \
  286.     juint _negative = (int32)(a).hi < 0;                                  \
  287.     if (_negative) {                                                      \
  288.     jlong_NEG(_a, a);                                                     \
  289.     } else {                                                              \
  290.     _a = a;                                                               \
  291.     }                                                                     \
  292.     if ((int32)(b).hi < 0) {                                              \
  293.     _negative ^= 1;                                                       \
  294.     jlong_NEG(_b, b);                                                     \
  295.     } else {                                                              \
  296.     _b = b;                                                               \
  297.     }                                                                     \
  298.     jlong_UDIVMOD(&(r), 0, _a, _b);                                       \
  299.     if (_negative)                                                        \
  300.     jlong_NEG(r, r);                                                      \
  301. }
  302.  
  303. #define jlong_MOD(r, a, b) {                                              \
  304.     jlong _a, _b;                                                         \
  305.     juint _negative = (int32)(a).hi < 0;                                  \
  306.     if (_negative) {                                                      \
  307.     jlong_NEG(_a, a);                                                     \
  308.     } else {                                                              \
  309.     _a = a;                                                               \
  310.     }                                                                     \
  311.     if ((int32)(b).hi < 0) {                                              \
  312.     jlong_NEG(_b, b);                                                     \
  313.     } else {                                                              \
  314.     _b = b;                                                               \
  315.     }                                                                     \
  316.     jlong_UDIVMOD(0, &(r), _a, _b);                                       \
  317.     if (_negative)                                                        \
  318.     jlong_NEG(r, r);                                                      \
  319. }
  320.  
  321. /*
  322.  * NB: b is a juint, not jlong or julong, for the shift ops.
  323.  */
  324. #define jlong_SHL(r, a, b) {                                              \
  325.     if (b) {                                                              \
  326.     jlong _a;                                                             \
  327.         _a = a;                                                           \
  328.         if ((b) < 32) {                                                   \
  329.         (r).lo = _a.lo << (b);                                            \
  330.         (r).hi = (_a.hi << (b)) | (_a.lo >> (32 - (b)));                  \
  331.     } else {                                                              \
  332.         (r).lo = 0;                                                       \
  333.         (r).hi = _a.lo << ((b) & 31);                                     \
  334.     }                                                                     \
  335.     } else {                                                              \
  336.     (r) = (a);                                                            \
  337.     }                                                                     \
  338. }
  339.  
  340. /* a is an int32, b is int32, r is jlong */
  341. #define jlong_ISHL(r, a, b) {                                             \
  342.     if (b) {                                                              \
  343.     jlong _a;                                                             \
  344.     _a.lo = (a);                                                          \
  345.     _a.hi = 0;                                                            \
  346.         if ((b) < 32) {                                                   \
  347.         (r).lo = (a) << (b);                                              \
  348.         (r).hi = ((a) >> (32 - (b)));                                     \
  349.     } else {                                                              \
  350.         (r).lo = 0;                                                       \
  351.         (r).hi = (a) << ((b) & 31);                                       \
  352.     }                                                                     \
  353.     } else {                                                              \
  354.     (r).lo = (a);                                                         \
  355.     (r).hi = 0;                                                           \
  356.     }                                                                     \
  357. }
  358.  
  359. #define jlong_SHR(r, a, b) {                                              \
  360.     if (b) {                                                              \
  361.     jlong _a;                                                             \
  362.         _a = a;                                                           \
  363.     if ((b) < 32) {                                                       \
  364.         (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b));                  \
  365.         (r).hi = (int32)_a.hi >> (b);                                     \
  366.     } else {                                                              \
  367.         (r).lo = (int32)_a.hi >> ((b) & 31);                              \
  368.         (r).hi = (int32)_a.hi >> 31;                                      \
  369.     }                                                                     \
  370.     } else {                                                              \
  371.     (r) = (a);                                                            \
  372.     }                                                                     \
  373. }
  374.  
  375. #define jlong_USHR(r, a, b) {                                             \
  376.     if (b) {                                                              \
  377.     jlong _a;                                                             \
  378.         _a = a;                                                           \
  379.     if ((b) < 32) {                                                       \
  380.         (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b));                  \
  381.         (r).hi = _a.hi >> (b);                                            \
  382.     } else {                                                              \
  383.         (r).lo = _a.hi >> ((b) & 31);                                     \
  384.         (r).hi = 0;                                                       \
  385.     }                                                                     \
  386.     } else {                                                              \
  387.     (r) = (a);                                                            \
  388.     }                                                                     \
  389. }
  390.  
  391. #define jlong_L2I(i, l)        ((i) = (l).lo)
  392. #define jlong_L2UI(ui, l)    ((ui) = (l).lo)
  393. #define jlong_L2F(f, l)        { double _d; jlong_L2D(_d, l); (f) = (float) _d; }
  394.  
  395. #define jlong_L2D(d, l) {                                                 \
  396.     int32 _negative;                                                      \
  397.     jlong _absval;                                                        \
  398.                                                                           \
  399.     _negative = (l).hi >> 31;                                             \
  400.     if (_negative) {                                                      \
  401.     jlong_NEG(_absval, l);                                                \
  402.     } else {                                                              \
  403.     _absval = l;                                                          \
  404.     }                                                                     \
  405.     (d) = (double)_absval.hi * 4.294967296e9 + _absval.lo;                \
  406.     if (_negative)                                                        \
  407.     (d) = -(d);                                                           \
  408. }
  409.  
  410. #define jlong_I2L(l, i)        ((l).hi = (i) >> 31, (l).lo = (i))
  411. #define jlong_UI2L(l, ui)    ((l).hi = 0, (l).lo = (ui))
  412. #define jlong_F2L(l, f)        { double _d = (double) f; jlong_D2L(l, _d); }
  413.  
  414. #define jlong_D2L(l, d) {                                                 \
  415.     int _negative;                                                        \
  416.     double _absval, _d_hi;                                                \
  417.     jlong _lo_d;                                                          \
  418.                                                                           \
  419.     _negative = ((d) < 0);                                                \
  420.     _absval = _negative ? -(d) : (d);                                     \
  421.                                                                           \
  422.     (l).hi = (juint)(_absval / 4.294967296e9);                            \
  423.     (l).lo = 0;                                                           \
  424.     jlong_L2D(_d_hi, l);                                                  \
  425.     _absval -= _d_hi;                                                     \
  426.     _lo_d.hi = 0;                                                         \
  427.     if (_absval < 0) {                                                    \
  428.     _lo_d.lo = (juint) -_absval;                                          \
  429.     jlong_SUB(l, l, _lo_d);                                               \
  430.     } else {                                                              \
  431.     _lo_d.lo = (juint) _absval;                                           \
  432.     jlong_ADD(l, l, _lo_d);                                               \
  433.     }                                                                     \
  434.                                                                           \
  435.     if (_negative)                                                        \
  436.     jlong_NEG(l, l);                                                      \
  437. }
  438.  
  439. #endif /* !HAVE_LONG_LONG */
  440.  
  441. /******************************************************************************/
  442. /*
  443. ** JDK Stuff -- This stuff is still needed while we're using the JDK
  444. ** dynamic linking strategy to call native methods.
  445. */
  446.  
  447. typedef union JRI_JDK_stack_item {
  448.     /* Non pointer items */
  449.     jint           i;
  450.     jfloat         f;
  451.     jint           o;
  452.     /* Pointer items */
  453.     void          *h;
  454.     void          *p;
  455.     unsigned char *addr;
  456. #ifdef IS_64
  457.     double         d;
  458.     long           l;        /* == 64bits! */
  459. #endif
  460. } JRI_JDK_stack_item;
  461.  
  462. typedef union JRI_JDK_Java8Str {
  463.     jint x[2];
  464.     jdouble d;
  465.     jlong l;
  466.     void *p;
  467.     float f;
  468. } JRI_JDK_Java8;
  469.  
  470. #ifdef HAVE_ALIGNED_LONGLONGS
  471. #define JRI_GET_INT64(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \
  472.                               ((_t).x[1] = ((jint*)(_addr))[1]),      \
  473.                               (_t).l )
  474. #define JRI_SET_INT64(_t, _addr, _v) ( (_t).l = (_v),                \
  475.                                    ((jint*)(_addr))[0] = (_t).x[0], \
  476.                                    ((jint*)(_addr))[1] = (_t).x[1] )
  477. #else
  478. #define JRI_GET_INT64(_t,_addr) (*(jlong*)(_addr))
  479. #define JRI_SET_INT64(_t, _addr, _v) (*(jlong*)(_addr) = (_v))
  480. #endif
  481.  
  482. /* If double's must be aligned on doubleword boundaries then define this */
  483. #ifdef HAVE_ALIGNED_DOUBLES
  484. #define JRI_GET_DOUBLE(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \
  485.                                ((_t).x[1] = ((jint*)(_addr))[1]),      \
  486.                                (_t).d )
  487. #define JRI_SET_DOUBLE(_t, _addr, _v) ( (_t).d = (_v),                \
  488.                                     ((jint*)(_addr))[0] = (_t).x[0], \
  489.                                     ((jint*)(_addr))[1] = (_t).x[1] )
  490. #else
  491. #define JRI_GET_DOUBLE(_t,_addr) (*(jdouble*)(_addr))
  492. #define JRI_SET_DOUBLE(_t, _addr, _v) (*(jdouble*)(_addr) = (_v))
  493. #endif
  494.  
  495. /******************************************************************************/
  496. #ifdef __cplusplus
  497. }
  498. #endif
  499. #endif /* JRI_MD_H */
  500. /******************************************************************************/
  501.